// pages/class_leave/class_leave.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    listArr: [],        //循环中班级请假信息界面所需数据暂时存放变量
    Arr: [],            //班级请假信息界面所需数据
    teacher_id: '',     //教职工号
    a: 0,               //第二次分组时，循环所需的变量
    b: [],              //存放两次分组后的数据
    c: 0,               //向listArr数组插入信息时，循环所需的变量
    d: 0,               //向listArr数组插入信息的循环中，maybe的下标
    sum: 0,             //listArr数组的对象个数
    list: [],           //传递两次分组后的数据
    con: 0,             //0常量
    show: false,        //搜索不到时显示
    show_text: '没有相关数据！',       //搜索不到时显示文字
    Akey: '',           //搜索框输入文字暂存变量
    i: 0                //搜索所需循环变量
  },
  GroupBy(array, fn){      //groupby分组函数
    const groups ={};
    array.forEach(
      function(item){
        const group = JSON.stringify(fn(item));
        groups[group] = groups[group] || [];
        groups[group].push(item);
      }
    );
    return Object.keys(groups).map(
      function(group){
        return groups[group];
      }
    );
  },
  /*
  实现思路：
  1、函数groupBy有两个形参，一为对象数组，二为匿名函数（该函数功能：返回对象的某个指定属性的属性值并存放在数组中）；
  2、groupBy函数内，先创建一个空对象；
  3、然后forEach遍历对象数组，遍历时要执行的函数中只有一个形参item（数组中的每个元素）；
  4、const group = JSON.stringify( fn(item) )，相当于先获取到对象数组中的某属性对应的属性值并放入数组中，然后再将属性值转换为json字符串；
  5、groups[group] = groups[group] || []，在js中对象也是关联数组，因此这里相当于做了两件事，一是把group作为groups的key，二是将对应的value初始化，第一次执行为空数组，循环执行时找到相同的属性时保持不变；
  6、groups[group].push( item )，这句相当于把对象数组中每个对象压入数组中作为value；
  7、最后，Object.keys(groups)是取出groups对象中的所有key，然后遍历一个个key组成的新数组，返回分好了组的二维数组
  */

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    this.setData({   //获取上个页面传过来的teacher_id
      teacher_id: options.teacher_id
    })
    var there = this
    this.getLeave()
    wx.getStorage({
      key: 'listArr',
      success (res) {
        //console.log(res.data)
        there.setData({
          Arr: res.data
        })
      }
    })
    try {
      var value = wx.getStorageSync('listArr')
      if (value) {
        // Do something with return value
      }
    } catch (e) {
      // Do something when catch error
    }
    wx.getStorage({
      key: 'list_group',
      success (res) {
        //console.log(res.data)
        there.setData({
          list: res.data
        })
      }
    })
    try {
      var value = wx.getStorageSync('list_group')
      if (value) {
        // Do something with return value
      }
    } catch (e) {
      // Do something when catch error
    }
  },

  getLeave(){    //获取请假信息
    var that = this
    wx.cloud.callFunction({      //调用云函数
      name: 'database_connect',
      data: {
        function_name:"findone",//方法名字  查找符合条件的数据
        name_collection:"leave",//集合名称
        name_doc:"",//文档名称（id）
        condition:{//条件
          teacher_id: that.data.teacher_id,
          pass: true
        },
        data:{

        }
      },
      success(res){
        //console.log("success",res);     //打印成功回调
        var h = [];
        res.result.data.sort((a, b) => a.stu_garde - b.stu_garde)
        //results是根据stu_garde分组后的数组
        const results = that.GroupBy(res.result.data, function(item){return [item.stu_garde];});
        //console.log(results)
        while(that.data.a < results.length){
          //maybe是在results的基础上再根据stu_class分组
          const maybe = that.GroupBy(results[that.data.a], function(item){return [item.stu_class];});
          //console.log(maybe)
          that.data.b[that.data.a] = maybe     //将分组后的数据放入b数组
          that.data.sum = that.data.sum + maybe.length    //更新listArr数组的最大长度，方便向listArr数组插入时使用循环
          while(that.data.c < that.data.sum){            //使用循环将stu_garde，stu_class，length信息插入到listArr数组
            that.data.listArr[that.data.c] = {
              stu_garde: (maybe[that.data.d][0]).stu_garde,   
              stu_class: (maybe[that.data.d][0]).stu_class,
              length: (maybe[that.data.d]).length,
              list_index1: that.data.a,
              list_index2: that.data.con
            }
            that.setData({
              c : that.data.c + 1,
              con : that.data.con + 1,
              d : that.data.d + 1
            })
          }
          that.setData({
            a : that.data.a + 1,
            d : 0,
            con : 0
          })
        }
        //console.log(that.data.listArr);
        wx.setStorage({     //数据缓存
          key:"listArr",
          data:that.data.listArr
        })
        try {
          wx.setStorageSync('listArr',that.data.listArr)
        } catch (e) { }
        wx.setStorage({     //数据缓存
          key:"list_group",
          data:that.data.b
        })
        try {
          wx.setStorageSync('list_group',that.data.b)
        } catch (e) { }
      },//成功的回调
      fail(res){
        console.log("fail",res)
      }
    })
  },

  //键盘输入时实时调用搜索方法
  input(e){
    //console.log(e.detail)
    this.search(e.detail.value)
  },

  search(key){         //根据输入框搜索数据
    this.setData({
      Akey: key,
      show: false
    })
    var that = this;
    wx.getStorage({          //获取缓存数据
      key: 'listArr',
      success (res) {
        //console.log(res.data)
        if (that.data.Akey == ''){            //搜索为空，显示所有
          that.setData({
            Arr: res.data
          })
        }else{ 
          var arr = [];   //暂时数组，存放数据
          //判断输入内容字符串本质是数字还是字符串,然后去匹配年级或者班级
          var regPos = /^\d+(\.\d+)?$/; //非负浮点数
          var regNeg = /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/; //负浮点数
          if(regPos.test(that.data.Akey) || regNeg.test(that.data.Akey)) {     //true，匹配年级
            while (that.data.i < res.data.length) {
              if ((res.data[that.data.i].stu_garde).indexOf(that.data.Akey) >= 0) {  //indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
                arr.push(res.data[that.data.i])
              }
              that.setData({
                i: that.data.i + 1
              })
            }
            that.setData({
              i: 0
            })
            if (arr.length == 0) {
              that.setData({
                Arr: [],
                show: true
              })
            } else {
              that.setData({
                Arr: arr
              })
            }
          } else {   //false,匹配班级
            while (that.data.i < res.data.length) {
              if ((res.data[that.data.i].stu_class).indexOf(that.data.Akey) >= 0) {
                arr.push(res.data[that.data.i])
              }
              that.setData({
                i: that.data.i + 1
              })
            }
            that.setData({
              i: 0
            })
            if (arr.length == 0) {
              that.setData({
                Arr: [],
                show: true
              })
            } else {
              that.setData({
                Arr: arr
              })
            }
          }    
        }
      }
    })
    try {
      var value = wx.getStorageSync('listArr')
      if (value) {
        // Do something with return value
      }
    } catch (e) {
      // Do something when catch error
    }
  },  

  toClass_detail(event){  //跳转class_detail
    //获取点击跳转对应的下标
    let index = event.currentTarget.dataset.index;
    wx.navigateTo({
      url: '/pages/teacher_class_detail/teacher_class_detail?index='+index+'&list='+JSON.stringify(this.data.b[(this.data.Arr[index]).list_index1][(this.data.Arr[index]).list_index2])  
    })
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {

  }
})